/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package Calculos;

import java.util.ArrayList;

/**
 *
 * @author Beto
 */
public class CalculaConcentrada {

    private double incremento=0.005;
    private double inicoViga;
    private double RA,RB;
    
    private ArrayList<double []> cargaCentrada=new ArrayList<double[]>();
    private ArrayList<double []> deformada=new ArrayList<double[]>();
    private static final double coeficienteE = 205*Math.pow(10, 9);

    public CalculaConcentrada(double inicioViga) {
       
        this.inicoViga=inicioViga;
    }




private void calculaReacaoApoios(double forca,double tamanhoViga,double posicao){
     ///////////////////Reação para RA///////////////////////

    double posicaoReal=posicao;
    //uma carga concentrada da carga resultante (como se fosse)
    RA=(forca*(tamanhoViga-posicaoReal))/tamanhoViga;


    ///////////////////////Reação para RB/////////////////

    RB=(forca*posicaoReal)/tamanhoViga;
}



    public void CalculaCargaCentrada(double forca,double tamanhoViga,double posicao){
        double resultados[]=new double[2];

        calculaReacaoApoios(forca, tamanhoViga, posicao);
        
        resultados[0]=MomentoFletorCentrada(forca, tamanhoViga,posicao);
        resultados[1]=EsforcoCortanteCentrada(forca, tamanhoViga,posicao);
        //new Graficos("Gráfico Carga Centrada", cargaCentrada);
    }




    private double MomentoFletorCentrada(double forca,double comprimento,double posicao){
        CalculaFuncaoFletorCentrada(forca, comprimento, posicao);
        return ((forca*posicao*(comprimento-posicao))/2);

    }

    private void CalculaFuncaoFletorCentrada(double forca,double comprimento,double posicao){
        int tamanhoVetor = (int) (comprimento / incremento);
        double x[] = new double[tamanhoVetor];
        double y[] = new double[tamanhoVetor];
        for (int i = 1; i < tamanhoVetor; i++) {
            x[i] = x[i - 1] + incremento;
        }

        for(int i=0;i<tamanhoVetor;i++){
            if(x[i]<=(posicao)){
                y[i]=(forca*x[i]*(comprimento-(posicao)))/comprimento;
            }
            else{
                y[i]=((forca*(posicao)*(comprimento-x[i]))/comprimento);
            }
        }
       // new Graficos("Gráfico Momento Fletor Força Centrada", x, y);
        cargaCentrada.add(x);
        cargaCentrada.add(y);
    }


    private double EsforcoCortanteCentrada(double forca,double comprimento,double posicao){
        CalculaFuncaoEContanteCentrada(forca, comprimento,posicao);
        return forca;//duvida aqui: o valor do esforço cortante é igual ao valor da carga aplicada??????????????
    }

    private void CalculaFuncaoEContanteCentrada(double forca,double comprimento,double posicao){
         int tamanhoVetor = (int) (comprimento / incremento);
        double x[] = new double[tamanhoVetor];
        double y[] = new double[tamanhoVetor];
        for (int i = 1; i < tamanhoVetor; i++) {
            x[i] = x[i - 1] + incremento;
        }
        for(int i=0;i< tamanhoVetor;i++){
            if(x[i]<=posicao){
                y[i]=(forca*(comprimento-(posicao)))/comprimento;
            }
          else{
                y[i]=(-1*(forca*(posicao)))/comprimento;
          }
        }


       // new Graficos("Gráfico Esforço Cortante Força Centrada", x, y);
        cargaCentrada.add(x);
        cargaCentrada.add(y);
    }

    public ArrayList<double[]> getCargaCentrada() {
        return cargaCentrada;
    }

    public double getRA() {
        return RA;
    }

    public double getRB() {
        return RB;
    }

public double calculaMomentoFletorNoPonto(double x, double forca,double comprimento,double posicao) {

        double resultado = 0;
        if(x<=(posicao)){
                resultado=(forca*x*(comprimento-(posicao)))/comprimento;
            }
            else{
                resultado=((forca*(posicao)*(comprimento-x))/comprimento);
            }

        return resultado;
    
}

    public double CalculaEContanteCentradaNoPonto(double x,double forca,double comprimento,double posicao){
        double resultado;

        if(x<=posicao){
            resultado=(forca*(comprimento-(posicao)))/comprimento;
        }
        else{
            resultado=(-1*(forca*(posicao)))/comprimento;
        }

        return resultado;
     }

     public void CalculaDeformadaVetor(double forca,double comprimento,double posicao, double iY){

        int tamanhoVetor = (int) (comprimento / incremento);
        double x[] = new double[tamanhoVetor];
        double y[] = new double[tamanhoVetor];

        for (int i = 1; i < tamanhoVetor; i++) {
            x[i] = x[i - 1] + incremento;
        }

        for(int i=0;i<tamanhoVetor;i++){
            y[i] = this.CalculoDeformadaPonto(x[i], forca, comprimento, posicao, iY);
        }

        deformada.add(x);
        deformada.add(y);
    }

    public double CalculoDeformadaPonto(double x,double forca ,double tamanhoViga, double posicao, double Iy){

        double L=tamanhoViga;
        double P=forca;
        double a=posicao;
        double b=(L-a);
        double resultado = 0;
        if(x <= a){
           resultado=P*b*x*((Math.pow(L, 2)) - (Math.pow(b, 2)) - Math.pow(x, 2));
        }

        // posição da Carga < x <= Tamanho da Viga
        if(x > a ){
           resultado=P*a*x*((Math.pow(L, 2)) - (Math.pow(a, 2)) - Math.pow(x, 2));
        }

        resultado/=6*L*coeficienteE*Iy;
        return resultado;
    }

    public ArrayList<double[]> getDeformada() {
        return deformada;
    }





}
